NeXTSTEP 3.1 (Developer) [x86]/NeXT Step 3.1 Intel dev.cdr.dmg/NextDeveloper/Makefiles/app/common.make

Text File | 1993-04-12 | 11KB | 326 lines

###############################################################################
#  NeXT common.make
#  Copyright 1992, NeXT Computer, Inc.
#
#  This makefile is common to all project-types (apps, subprojects,
#  bundles, and palettes).  It can also prove useful to custom Makefiles
#  needing generic project-building functionality, but users should be aware
#  that interfaces supported at this level are private to the app makefiles
#  and may change from release to release.
#
###############################################################################


all::

SUPPORTFILES = IB.nproj Makefile makefile $(NAME).iconheader \
    Makefile.preamble Makefile.postamble *.project SGS_ENV

SRCFILES = $(CLASSES) \
    $(MFILES) $(CFILES) $(CCFILES) $(CAPCFILES) $(CXXFILES) $(CPPFILES) \
    $(HFILES) $(PSWFILES) $(PSWMFILES) $(DBMODELAFILES) \
    $(GLOBAL_RESOURCES) \
    $(OTHERSRCS) $(OTHERLINKED) $(OTHER_SOURCEFILES)

### Compute all the possible derived files and directories for them:

# Defaults for NeXT-specific Release Control options
SRCROOT = .
SYMROOT = .
OBJROOT = .
RC_ARCHS = `/usr/bin/arch`
RC_CFLAGS = -arch `/usr/bin/arch`

# Directory for .o files (can be thrown away)
OFILE_DIR = $(OBJROOT)/$(ARCH_LIST)obj
# Directory for all other derived files (contains symbol info. for debugging)
SYM_DIR = $(SYMROOT)/sym
# For compatibility:
DERIVED_DIR = $(OFILE_DIR)
DERIVED_SRC_DIR = $(SYM_DIR)

$(OFILE_DIR) $(SYM_DIR):
    @$(MKDIRS) $@

MSGOFILES = $(MSGFILES:.msg=Speaker.o) $(MSGFILES:.msg=Listener.o)
MSGDERIVEDMFILES = $(MSGFILES:.msg=Speaker.m) $(MSGFILES:.msg=Listener.m)

ALLMIGFILES = $(MIGFILES) $(DEFSFILES)

MIGOFILES = $(MIGFILES:.mig=User.o) $(MIGFILES:.mig=Server.o)
DEFSOFILES = $(DEFSFILES:.defs=User.o) $(DEFSFILES:.defs=Server.o)
ALLMIGOFILES = $(MIGOFILES) $(DEFSOFILES)

MIGDERIVEDCFILES = $(MIGFILES:.mig=User.c) $(MIGFILES:.mig=Server.c)
DEFSDERIVEDCFILES = $(DEFSFILES:.defs=User.c) $(DEFSFILES:.defs=Server.c)
ALLMIGDERIVEDCFILES = $(MIGDERIVEDCFILES) $(DEFSDERIVEDCFILES)

EARLY_OFILES = $(PSWFILES:.psw=.o) $(PSWMFILES:.pswm=.o)

INITIAL_TARGETS = $(OFILE_DIR) $(SYM_DIR) $(EARLY_OFILES) $(MSGOFILES) $(ALLMIGOFILES) $(PRECOMPS) $(OTHER_INITIAL_TARGETS)

SUBPROJ_OFILES = $(SUBPROJECTS:.subproj=_subproj.o)
OFILES = $(SUBPROJ_OFILES) $(CLASSES:.m=.o) $(MFILES:.m=.o) $(CFILES:.c=.o) \
    $(CCFILES:.cc=.o) $(CAPCFILES:.C=.o) $(CXXFILES:.cxx=.o) \
    $(CPPFILES:.cpp=.o) $(EARLY_OFILES) $(OTHERLINKEDOFILES)
#    Note: It would be nice to put $(OTHERRELOCATABLES) in this list someday
#          when PB provides full paths for the contents of this variable.

# Derived resources:
DBMODELS = $(DBMODELAFILES:.dbmodela=.dbmodel)

HELP_DIRS = Help
HELP_STORES = $(HELP_DIRS:=.store) $(OTHER_HELP_DIRS:=.store)

### Set defaults for many values used throughout the app Makefiles

# Default extension for bundles (directories containing object code and resources)
BUNDLE_EXTENSION = .bundle

MAKEFILES = Makefile

PRODUCT_DEPENDS = $(OFILES) $(OTHER_OFILES) $(DBMODELS) \
    $(ICONHEADER) $(APPICON) $(DOCICONS) $(MAKEFILES) \
    $(OTHER_PRODUCT_DEPENDS)

GARBAGE = $(PSWFILES:.psw=.c) $(PSWMFILES:.pswm=.m) \
    $(PSWFILES:.psw=.h) $(PSWMFILES:.pswm=.m) \
    $(SYMROOT)/$(NAME).app $(SYMROOT)/$(NAME).debug \
    $(SYMROOT)/$(NAME).profile $(SYMROOT)/$(NAME).bundle \
    $(SYMROOT)/$(NAME) $(SYMROOT)/$(NAME).palette \
    $(OBJROOT)/*obj $(OBJROOT)/*debug_obj $(OBJROOT)/*profile_obj \
    $(SYM_DIR) *~ $(LANGUAGE).lproj/*~ \
    Makefile.dependencies $(OTHER_GARBAGE) gmon.out \
    $(PRECOMPS) $(OTHER_INITIAL_TARGETS)

# Default name for file to use as "reference time of last build"
CHANGES_FILE = .lastBuildTime

# Defaults for who to chown executables to when installing
INSTALL_AS_USER = root
INSTALL_AS_GROUP = wheel

# Default compiler options
OPTIMIZATION_CFLAG = -O
NORMAL_CFLAGS = -g $(OPTIMIZATION_CFLAG) -Wall
DEBUG_CFLAGS = -g -Wall -DDEBUG
PROFILE_CFLAGS = -g -pg $(OPTIMIZATION_CFLAG) -Wall -DPROFILE
C++CFLAGS = -D__cplusplus

# Defaults strip options
RELOCATABLE_STRIP_OPTS = -x -u
DYLD_APP_STRIP_OPTS = -A -n
APP_STRIP_OPTS =   # Set this to $(DYLD_APP_STRIP_OPTS) when doing dynaloading yourself

# Various commands:
SHELL  = /bin/sh
FASTCP = /usr/lib/fastcp
CHANGES = /usr/lib/changes
CHOWN  = /etc/chown
CHMOD  = /bin/chmod
TAR    = /bin/tar
STRIP  = /bin/strip
RM     = /bin/rm
LN     = /bin/ln
ECHO   = /bin/echo
MKDIRS = /bin/mkdirs
TOUCH  = /usr/bin/touch
AWK    = /bin/awk
PSWRAP = /usr/bin/pswrap
MSGWRAP = /usr/bin/msgwrap
MIG    = /usr/bin/mig
DBC    = /NextDeveloper/Apps/DBModeler.app/dbcompiler
COMPRESSHELP = /usr/bin/compresshelp

ADAPTOR_SEARCH_PATH = $(HOME)/Library/Adaptors /LocalLibrary/Adaptors /NextLibrary/Adaptors

# Set VPATH via a variable so clients of common.make can reuse it when overriding VPATH
NORMAL_VPATH = $(OFILE_DIR):$(SYM_DIR):$(LANGUAGE).lproj:$(PRODUCT_ROOT)
VPATH = $(VPATH_PREAMBLE)$(NORMAL_VPATH)$(VPATH_POSTAMBLE)


### Use a set of basic suffix-style rules:

COMMON_APP_MAKEFILE_DIR = /NextDeveloper/Makefiles/app
include $(COMMON_APP_MAKEFILE_DIR)/basicrules.make


### Define all the targets necessary at every level of the project-hierarchy:

# The following 2 rules do the recursion into subprojects and
# bundles of this (sub)project and does a 'make project' for each one in its
# respective directories.  This insures that we do not rely on the directory
# timestamp or "hacK" file to know whether or not something has changed.

subprojs $(SUBPROJ_OFILES):
    @(targets=`$(CHANGES) $(PRODUCT_ROOT)/$(CHANGES_FILE) "$(OFILE_DIR)" $(SUBPROJECTS)`;\
    for ofile in $(SUBPROJ_OFILES) none ; do \
       if [ $$ofile = "none" ] ; then break; fi ; \
       if [ ! -f $(OFILE_DIR)/$$ofile ] ; then \
          targets="$(SUBPROJECTS)" ; break; \
       fi ; \
    done ; \
    if [ "$(OBJROOT)" = "$(SRCROOT)" ] ; then \
       prod_root="../$(PRODUCT_ROOT)" ;\
       ofile_dir="../$(OFILE_DIR)" ;\
       sym_dir="../$(SYM_DIR)" ;\
    else \
       prod_root="$(PRODUCT_ROOT)" ; \
       ofile_dir="$(OFILE_DIR)" ;\
       sym_dir="$(SYM_DIR)" ;\
    fi ;\
    for sub in $$targets none ; do \
       if [ $$sub = "none" ] ; then break; fi ;\
       cd $$sub; $(ECHO) Making $$sub ; \
       $(MAKE) project "NAME = $$sub" \
                  "PRODUCT_ROOT = $$prod_root" \
               "OFILE_DIR = $$ofile_dir/$$sub" \
               "SUBPROJ_OFILE_DIR = $$ofile_dir" \
               "SYM_DIR = $$sym_dir/$$sub" \
               "APP_MAKEFILE_DIR = $(APP_MAKEFILE_DIR)" \
               "SRCROOT = $(SRCROOT)" \
               "OBJROOT = $(OBJROOT)" \
               "SYMROOT = $(SYMROOT)" \
               "PROJ_CFLAGS = $(CFLAGS) -I$$sym_dir $(PROJ_CFLAGS) $(OTHER_CFLAGS)" \
               "RC_CFLAGS = $(RC_CFLAGS)" ; \
       cd .. ; $(ECHO) Finished making $$sub ; \
    done )

bundles:
    @(targets=`$(CHANGES) $(PRODUCT_ROOT)/$(CHANGES_FILE) "$(OFILE_DIR)" $(BUNDLES)` ; \
    if [ "$(OBJROOT)" = "$(SRCROOT)" ] ; then \
       prod_root="../$(PRODUCT_ROOT)" ;\
       ofile_dir="../$(OFILE_DIR)" ;\
       sym_dir="../$(SYM_DIR)" ;\
    else \
       prod_root="$(PRODUCT_ROOT)" ; \
       ofile_dir="$(OFILE_DIR)" ;\
       sym_dir="$(SYM_DIR)" ;\
    fi ;\
    for bun in $$targets none ; do \
       if [ $$bun = "none" ] ; then break; fi ; \
       cd $$bun; $(ECHO) Making $$bun ; \
       $(MAKE) project "NAME = $$bun" \
                       "BUNDLE_DIR = $$prod_root/$$bun" \
                       "REL_BUNDLE_DIR = $$bun" \
               "OFILE_DIR = $$ofile_dir/$$bun" \
               "SYM_DIR = $$sym_dir/$$bun" \
               "APP_MAKEFILE_DIR = $(APP_MAKEFILE_DIR)" \
               "SRCROOT = $(SRCROOT)" \
               "OBJROOT = $(OBJROOT)" \
               "SYMROOT = $(SYMROOT)" \
               "PROJ_CFLAGS = $(CFLAGS) -I$$sym_dir $(PROJ_CFLAGS) $(OTHER_CFLAGS)" \
               "RC_CFLAGS = $(RC_CFLAGS)" ; \
       cd .. ; $(ECHO) Finished making $$bun ; \
    done )

# The following rule actually insures that resources for this particular level in the project hierarchy get copied over to the appropriate place in the PRODUCT_ROOT.  Note that we depend on VPATH including $(LANGUAGE).lproj so that the LOCAL_RESOURCES are found correctly.  FASTCP is used to minimize the copying of files, since most resources are likely to be up to date most of the time.

resources:: $(LOCAL_RESOURCES) $(GLOBAL_RESOURCES) $(HELP_STORES) $(OTHER_RESOURCES)
    @($(MKDIRS) $(PRODUCT_ROOT)/$(LANGUAGE).lproj ; \
    if [ "$(LOCAL_RESOURCES)" != "" ] ; then \
       locals="" ; \
       for resource in $(LOCAL_RESOURCES) none ; do   \
          insert="true"; \
          for helpdir in $(HELP_DIRS) $(OTHER_HELP_DIRS) none ; do \
             if [ "$$resource" = "$$helpdir" ] ; \
               then insert="false"; \
         fi ; \
          done ; \
          if [ "$$insert" = "true" ] ; then \
             locals="$$locals $$resource" ; \
          fi ; \
       done ; \
       $(FASTCP) $$locals $(PRODUCT_ROOT)/$(LANGUAGE).lproj ; \
    fi ; \
    if [ "$(GLOBAL_RESOURCES)" != "" ] ; then \
       $(FASTCP) $(GLOBAL_RESOURCES) $(PRODUCT_ROOT) ; \
    fi )


# rules for copying, cleaning and making dependencies

.bproj.copy:
    @(cd $*.bproj; $(MAKE) copy "NAME=$*" "DEST=$(DEST)/$*.bproj")
.subproj.copy:
    @(cd $*.subproj; $(MAKE) copy "NAME=$*" "DEST=$(DEST)/$*.subproj")

.bproj.clean:
    (cd $*.bproj; $(MAKE) clean "NAME=$*" "DEST=$(DEST)/$*.bproj")
.subproj.clean:
    (cd $*.subproj; $(MAKE) clean "NAME=$*" "DEST=$(DEST)/$*.subproj")

.bproj.depend:
    (if [ $(SYMROOT) = $(SRCROOT) ] ; then \
       sym_dir="../$(SYM_DIR)" ;\
    else \
       sym_dir="$(SYM_DIR)" ;\
    fi ;\
    cd $*.bproj; \
    $(MAKE) depend "NAME=$*" "PROJ_CFLAGS = $(CFLAGS) $(PROJ_CFLAGS) $(OTHER_CFLAGS) -I$$sym_dir/$*.bproj" )
.subproj.depend:
    (cd $*.subproj; \
    $(MAKE) depend "NAME=$*" "PROJ_CFLAGS = $(CFLAGS) $(PROJ_CFLAGS) $(OTHER_CFLAGS) -I$$sym_dir/$*.subproj")

SRCROOT DEST:
    @if [ -n "${$@}" ]; then exit 0; \
    else $(ECHO) Must define $@; exit 1; fi

$(DEST)::
    -$(RM) -rf $(DEST)
    @$(MKDIRS) $(DEST)

$(NAME).copy:: DEST $(DEST) $(SRCFILES)
    @(if [ "$(SRCFILES)" != "" ] ; then \
           $(ECHO) "$(TAR) chf - $(SRCFILES) | (cd $(DEST); $(TAR) xf -)" ; \
           $(TAR) chf - $(SRCFILES) | (cd $(DEST); $(TAR) xf -) ; \
    fi ; \
    $(MKDIRS) $(DEST)/$(LANGUAGE).lproj ; \
    if [ "$(LOCAL_RESOURCES)" != "" ] ; then \
       $(ECHO) "(cd $(LANGUAGE).lproj; $(TAR) chf - $(LOCAL_RESOURCES)) | (cd $(DEST)/$(LANGUAGE).lproj; $(TAR) xf - )" ; \
       (cd $(LANGUAGE).lproj; $(TAR) chf - $(LOCAL_RESOURCES)) | (cd $(DEST)/$(LANGUAGE).lproj; $(TAR) xf -) ; \
    fi ; \
    supportfiles="" ; \
    for i in $(SUPPORTFILES) $(APPICON) $(DOCICONS) none ; do \
        if [ -r $$i -a ! -r $(DEST)/$$i ] ; then \
        supportfiles="$$supportfiles $$i" ; \
        fi ; \
    done ; \
    if [ "$$supportfiles" != "" ] ; then \
       $(ECHO) "$(TAR) chf - $$supportfiles | (cd $(DEST); $(TAR) xf -)" ; \
       $(TAR) chf - $$supportfiles | (cd $(DEST); $(TAR) xf -) ; \
    fi)

$(NAME).clean::
    @if [ ! -w . ] ; then $(ECHO) '***' project write-protected; exit 1 ; fi
    $(RM) -rf $(GARBAGE)


# Build a set of dependencies for current level into Makefile.dependencies

Makefile.dependencies:: $(CLASSES) $(MFILES) $(CFILES) $(CCFILES) $(CAPCFILES) $(CXXFILES) $(CPPFILES)
    $(RM) -f Makefile.dependencies
    $(CC) -MM $(ALL_CFLAGS) $(CLASSES) $(MFILES) $(CFILES) \
                $(CCFILES) $(CAPCFILES) $(CXXFILES) $(CPPFILES) \
       >  Makefile.dependencies


copy:: $(NAME).copy $(BUNDLES:.bproj=.copy) $(SUBPROJECTS:.subproj=.copy)

writable::
    @chmod -R +w *

protected::
    @chmod -R a-w *

installsrc:: SRCROOT
    @($(MAKE) copy "DEST=$(SRCROOT)")

installhdrs::

clean:: $(NAME).clean  $(BUNDLES:.bproj=.clean) $(SUBPROJECTS:.subproj=.clean)